home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.06 Jun 90 / MacMainframe Source / C-Source next >
Encoding:
Text File  |  1989-09-27  |  19.2 KB  |  817 lines  |  [TEXT/nX^n]
  1. int storeHanInGlobal(paramPtr, globalName, han)
  2. /*
  3.     Convert the handle to HexStr representation and
  4.     store in the HC global container globalName.
  5.     If handle is zero, store empty in the global.
  6.     This lets the HyperCard script test to see if
  7.     memory has been allocated (not empty == allocated).
  8.     
  9.     Returns result code.
  10. */
  11.     XCmdPtr     paramPtr;
  12.     char        *globalName;
  13.     Handle        han;
  14. {
  15.     Handle        tempHan;
  16.     Str255        tempPstr;
  17.     char        hanCstr[kMaxLenLine];
  18.     
  19.     if(han==NIL)
  20.         strcpy(hanCstr, kEmptyStr);
  21.     else
  22.         convertHanToHexStr(hanCstr, han);    /*    convert handle to hex strng    */
  23.     copyCtoPstr(tempPstr, globalName);        /*    make Pascal version of name    */
  24.     tempHan = CopyStrToHand(hanCstr);        /*    store string for passing    */
  25.     SetGlobal(paramPtr, tempPstr, tempHan);    /*    store contents into global    */
  26.     DisposHandle(tempHan);
  27.     return MemError();
  28. }    /*    --------------------------------------------    storeHanInGlobal    */
  29.  
  30. int fetchHanFromGlobal(paramPtr, globalName, han)
  31. /*
  32.     Fetch the handle stored in HexStr
  33.     in the HC global container globalName.
  34.     
  35.     Returns result code:
  36.         TRUE        successful, found handle
  37.         FALSE        handle is NIL
  38. */
  39.     XCmdPtr     paramPtr;                        /*    HyperCard connection    */
  40.     char        *globalName;                    /*    name of global            */
  41.     Handle        *han;                            /*    pointer to handle        */
  42. {
  43.     Handle        hGlobalString;                    /*    string stored in global    */
  44.     Str255        tempPstr;
  45.     
  46.     copyCtoPstr(tempPstr, globalName);            /*    copy, not in-place conv    */
  47.     HLock(hGlobalString = GetGlobal(paramPtr, tempPstr));
  48.     convertHexStrtoHan(han, *hGlobalString);
  49.     HUnlock(hGlobalString);
  50.     if(*han==NIL)
  51.         return FALSE; 
  52.     else
  53.         return TRUE;
  54. }    /*    --------------------------------------------    fetchHanFromGlobal    */
  55.  
  56. void convertHanToHexStr(hexStr, han)
  57. /*
  58.     Convert the Handle to 8-char (+ terminator) hex string representation.
  59. */
  60.     char    *hexStr;
  61.     Handle    han;
  62. {
  63.     short    digit,
  64.             shiftCnt = 32;
  65.     
  66.     do
  67.     {
  68.         shiftCnt -= 4;
  69.         digit = '0' + (((short) ( (long) han >> shiftCnt)) & 0x000F);
  70.         if(digit > '9')
  71.             digit += 7;                        /*    A-F hex digit    */
  72.         *hexStr++ = digit;
  73.     }
  74.     while(shiftCnt>0);
  75.     *hexStr = '\0';                            /*    add terminator    */
  76. }    /*    --------------------------------------------    convertHanToHexStr    */
  77.  
  78. void convertHexStrtoHan(han, hexStr)
  79. /*
  80.     Convert the hex string representation to a Handle.
  81.     The HexStr representation must be a C-string.
  82.     Only the least-significant 8 hex digits are used.
  83.     Assumes that handle is already locked.
  84.     
  85.     Returns NIL for handle if there are not 8 hex digits.
  86. */
  87.     Handle    *han;
  88.     char    *hexStr;
  89. {
  90.     unsigned long    digit,
  91.                     hanVal=0L;
  92.     short            shiftCnt=0,
  93.                     i;
  94.     Str255            tempPstr;
  95.     
  96.     if(strlen(hexStr)!=8)
  97.     {
  98.         *han = NIL;
  99.         return;
  100.     }
  101.     copyCtoPstr(tempPstr, hexStr);
  102.     for(i=tempPstr[0]; i>0 && shiftCnt < 32; i--)
  103.     {
  104.         digit = tempPstr[i] - '0';        /*    unsigned, result is positive    */
  105.         if(digit>9L)
  106.             digit -= 7L;                /*    A-F hex digit                    */
  107.         if(digit>'F')
  108.         {
  109.             *han = NIL;
  110.             return;
  111.         }
  112.         digit <<= shiftCnt;                /*    shift left                        */
  113.         hanVal = hanVal | digit;        /*    insert value                    */
  114.         shiftCnt += 4;
  115.     }
  116.     *han = (Handle) hanVal;
  117. }    /*    --------------------------------------------    convertHexStrtoHan    */
  118.  
  119. void copyCtoPstr(Pstr, Cstr)
  120. /*
  121.     Copy the Cstr to the Pstr.
  122.     Allows us to make a P-string copy without
  123.     doing it in-place.
  124. */
  125.     Str255    Pstr;
  126.     char    *Cstr;
  127. {
  128.     short    i=0;
  129.     
  130.     while(*Cstr!=0)
  131.         Pstr[++i] = *Cstr++;
  132.     Pstr[0] = i;
  133. }    /*    --------------------------------------------    copyCtoPstr            */
  134.  
  135. /* -----------------------------------------------------------------
  136.     Program:        TriData3270 XFCN
  137.     
  138.     Version:        v2
  139.     
  140.     History:        05/04/89    v1, original
  141.                     07/04/89    v2, revised memory model
  142.     
  143.     Author:            John R. Powers, III
  144.                     Easy Street Software
  145.                     16373 Alexander Avenue
  146.                     Monte Sereno, CA 95030
  147.                     (408) 395-1158
  148.                     (408) 395-3308 msg.
  149.  
  150.     Computer:        Mac II with System v6.0.2
  151.     
  152.     Compiler:        MPW-C v3.0    
  153.  
  154.     Usage:
  155.     
  156.         get TriData3270("command", "session", SAM, params, "container")
  157.         
  158.         Requires HyperCard version 1.2 or better.
  159.         
  160.     Files:
  161.     
  162.         TriData3270.c        This source file
  163.         TD3270main.c        CODE called by TriData3270State
  164.         TriData3270 Lab        HyperCard stack for testing
  165.         TriData3270.h        General header
  166.         
  167.     Full Build:
  168.  
  169.         # TriData3270 XFCN
  170.         C -b  TriData3270.c -mbg off -sym off
  171.         Link ∂
  172.             -rt XFCN=16373 ∂
  173.             -m ENTRYPOINT ∂
  174.             -sg TriData3270 ∂
  175.             TriData3270.c.o ∂
  176.             "{Libraries}"Interface.o ∂
  177.             "{CLibraries}"StdCLib.o ∂
  178.             -o "TriData3270 Lab"
  179.         save -a
  180.         
  181. ----------------------------------------------------------------- */
  182.  
  183. #include    <HyperXCmd.h>
  184. #include    <Memory.h>
  185. #include    <Types.h>
  186. #include    <Resources.h>
  187.  
  188. #include    "TriData3270.h"
  189.  
  190. /*
  191.         Prototypes.
  192. */
  193.  
  194. void    makeHexStr(char *hexStr, short value);
  195. void    pTD3270main (XCmdPtr paramPtr, short opFlag);
  196.  
  197. /*
  198.         Main program and entry point for XFCN.
  199.         
  200.         Get common code resource and continue with that.
  201.         Use opFlag = kOp3270 (TriData3270 XFCN).
  202. */
  203.  
  204. pascal void    entryPoint(paramPtr)
  205.  
  206.     XCmdPtr     paramPtr;                /*    the HyperCard connection        */
  207. {
  208.     short        opFlag=kOp3270,
  209.                 result;
  210.     char        msg[kMaxLenLine];
  211.     Handle        hMsg,
  212.                 hTD3270main;
  213.     ProcPtr        pTD3270main;
  214.     
  215.     hTD3270main = GetNamedResource(kRsrcMainType, kRsrcMainName);
  216.     result = ResError();
  217.     if(result!=noErr)
  218.     {
  219.         makeHexStr(msg, result);
  220.         hMsg = (Handle) NewHandle((long) (strlen(msg)+1));
  221.         HLock(hMsg);
  222.         strcpy(*hMsg, msg);
  223.         HUnlock(hMsg);
  224.         paramPtr->returnValue = hMsg;
  225.         return;
  226.     }
  227.     LoadResource(hTD3270main);
  228.     MoveHHi(hTD3270main);
  229.     HLock(hTD3270main);
  230.     pTD3270main = (ProcPtr) *hTD3270main;
  231.     pTD3270main (paramPtr, opFlag);
  232.     HUnlock(hTD3270main);
  233.     ReleaseResource(hTD3270main);
  234.     return;
  235. }    /*    --------------------------------------------    entryPoint            */
  236.  
  237. void makeHexStr(hexStr, value)
  238. /*
  239.     Convert the value to 4-char (+ terminator) hex string representation.
  240. */
  241.     char    *hexStr;
  242.     short    value;
  243. {
  244.     short    digit,
  245.             shiftCnt = 16;
  246.     
  247.     while(shiftCnt>0);
  248.     {
  249.         shiftCnt -= 4;
  250.         digit = '0' + ((value>>shiftCnt) & 0x000F);
  251.         if(digit > '9')
  252.             digit += 7;                        /*    A-F hex digit    */
  253.         *hexStr++ = digit;
  254.     }
  255.     *hexStr = '\0';                            /*    add terminator    */
  256. }    /*    --------------------------------------------    makeHexStr            */
  257.  
  258. /* -----------------------------------------------------------------
  259.     Program:        TriData3270State XFCN
  260.     
  261.     Version:        v1.0a
  262.     
  263.     History:        xx/xx/89    v1.0a, original
  264.     
  265.     Author:            John R. Powers, III
  266.                     Easy Street Software
  267.                     16373 Alexander Avenue
  268.                     Monte Sereno, CA 95030
  269.                     (408) 395-1158
  270.                     (408) 395-3308 msg.
  271.  
  272.     Computer:        Mac II with System v6.0.2
  273.     
  274.     Compiler:        MPW-C v3.0    
  275.  
  276.     Usage:
  277.     
  278.         get TriData3270State(command, session)
  279.         
  280.         Requires HyperCard version 1.2 or better.
  281.         
  282.     Files:
  283.     
  284.         TriData3270State.c    This source file
  285.         TD3270main.c        CODE called by TriData3270State
  286.         TriData3270 Lab        HyperCard stack for testing
  287.         TriData3270.h        General header
  288.         
  289.     Full Build:
  290.  
  291.         # TriData3270State XFCN
  292.         C -b  TriData3270State.c -mbg off -sym off
  293.         Link ∂
  294.             -rt XFCN=16374 ∂
  295.             -m ENTRYPOINT ∂
  296.             -sg TriData3270State ∂
  297.             TriData3270State.c.o ∂
  298.             "{Libraries}"Interface.o ∂
  299.             "{CLibraries}"StdCLib.o ∂
  300.             -o "TriData3270 Lab"
  301.         save -a
  302.         
  303. ----------------------------------------------------------------- */
  304.  
  305. #include    <HyperXCmd.h>
  306. #include    <Memory.h>
  307. #include    <Types.h>
  308. #include    <Resources.h>
  309.  
  310. #include    "TriData3270.h"
  311.  
  312. /*
  313.         Prototypes.
  314. */
  315.  
  316. void    makeHexStr(char *hexStr, short value);
  317. void    pTD3270main (XCmdPtr paramPtr, short opFlag);
  318.  
  319. /*
  320.         Main program and entry point for XFCN.
  321.         
  322.         Get common code resource and continue with that.
  323.         Use opFlag = kOp3270State (TriData3270State XFCN).
  324. */
  325.  
  326. pascal void    entryPoint(paramPtr)
  327.  
  328.     XCmdPtr     paramPtr;                /*    the HyperCard connection        */
  329. {
  330.     short        opFlag=kOp3270State,
  331.                 result;
  332.     char        msg[kMaxLenLine];
  333.     Handle        hMsg,
  334.                 hTD3270main;
  335.     ProcPtr        pTD3270main;
  336.     
  337.     hTD3270main = GetNamedResource(kRsrcMainType, kRsrcMainName);
  338.     result = ResError();
  339.     if(result!=noErr)
  340.     {
  341.         makeHexStr(msg, result);
  342.         hMsg = (Handle) NewHandle((long) (strlen(msg)+1));
  343.         HLock(hMsg);
  344.         strcpy(*hMsg, msg);
  345.         HUnlock(hMsg);
  346.         paramPtr->returnValue = hMsg;
  347.         return;
  348.     }
  349.     LoadResource(hTD3270main);
  350.     MoveHHi(hTD3270main);
  351.     HLock(hTD3270main);
  352.     pTD3270main = (ProcPtr) *hTD3270main;
  353.     pTD3270main (paramPtr, opFlag);
  354.     HUnlock(hTD3270main);
  355.     ReleaseResource(hTD3270main);
  356.     return;
  357. }    /*    --------------------------------------------    entryPoint            */
  358.  
  359. void makeHexStr(hexStr, value)
  360. /*
  361.     Convert the value to 4-char (+ terminator) hex string representation.
  362. */
  363.     char    *hexStr;
  364.     short    value;
  365. {
  366.     short    digit,
  367.             shiftCnt = 16;
  368.     
  369.     while(shiftCnt>0);
  370.     {
  371.         shiftCnt -= 4;
  372.         digit = '0' + ((value>>shiftCnt) & 0x000F);
  373.         if(digit > '9')
  374.             digit += 7;                        /*    A-F hex digit    */
  375.         *hexStr++ = digit;
  376.     }
  377.     *hexStr = '\0';                            /*    add terminator    */
  378. }    /*    --------------------------------------------    makeHexStr            */
  379.  
  380. /*
  381.         main program and entry point
  382.         
  383.         The is intended to be called as a CODE resource,
  384.         not an XCMD or XFCN.
  385.         
  386.         Call with opFlag==kOp3270 for TriData3270 functionality.
  387.         Call with opFlag==kOp3270State for TriData3270State functionality.
  388.         
  389.         TriData3270State is a subset of TriData3270.  There is
  390.         so much common code that this approach eliminates
  391.         redundant source and object code.
  392. */
  393.  
  394. void entryPoint(paramPtr, opFlag)
  395.  
  396.     XCmdPtr     paramPtr;                /*    the HyperCard connection        */
  397.     short        opFlag;
  398. {
  399.     masBlk        *pMas;                    /*    master memory pointer            */
  400.     sesBlk        *pSes;
  401.     Handle        hMas,                    /*    master block handle                */
  402.                 hSes;
  403.     char        sessionGlobalName[kMaxLenName],
  404.                   command[kMaxLenCmd],    /*    command string                    */
  405.                 returnList[kMaxLenRet];    /*    string list for return            */
  406.     short        result,                    /*    result code for return            */
  407.                 ignore,
  408.                 debugFlag,                /*    debug flag                        */
  409.                 reqResult,                /*    result code from API            */
  410.                 status,                    /*    verb queue status code            */
  411.                 cmdNum,                    /*    command number                    */
  412.                 blockIndx,                /*    queue/request block index        */
  413.                 numParams,                /*    number of XFCN parameters        */
  414.                 sessionIndx;
  415.     WORD        wIgnore;
  416.                                         /*    Map command index to            */
  417.                                         /*    req and queue indexes            */
  418.     short    blockIndxTable[] =
  419.             {
  420.                 kIndxConnPS,            /*    ConnPS                            */
  421.                 kIndxCpyToPS,            /*    CpyToPS                            */
  422.                 kIndxDiscPS,            /*    DiscPS                            */
  423.                 kIndxGetCurs,            /*    GetCurs                            */
  424.                 kIndxSendKey,            /*    SendKey                            */
  425.                 kIndxSetCurs,            /*    SetCurs                            */
  426.                 kIndxCpyfBuf,            /*    CpyfBuf                            */
  427.                 kIndxGetUpd,            /*    GetUpd                            */
  428.                 kIndxCloseHC,            /*    CloseHC (no queue)                */
  429.                 kIndxOpenHC,            /*    OpenHC (no queue)                */
  430.                 kIndxSendKey,            /*    SendAID => SendKey                */
  431.                 kIndxSendKey,            /*    SendText => SendKey                */
  432.                 kIndxInit,                /*    no queue and no request blocks    */
  433.                 kIndxTerm                /*    no queue and no request blocks    */
  434.             };
  435. /*
  436.         Setup return string.
  437.         Check for opFlag validity.
  438. */
  439.     *returnList = kCterm;
  440.     if(opFlag!=kOp3270 && opFlag!=kOp3270State)
  441.     {
  442.         resultForHC(paramPtr, kRcHuhOp, returnList);
  443.         return;
  444.     }
  445.  
  446. void getContainerData(paramPtr, container, hGlobalData)
  447. /*
  448.     Get the data from the container described in "container".
  449.     The kTmpGlobalPname is a hypercard global used for temporary storage.
  450.     Return a handle to the HyperCard data.
  451.     The HyperCard data is stored as a C string.
  452.     
  453.     Method:
  454.     
  455.         Send a message to HC to put the data into a global.
  456.         Get the contents of the global.
  457.         
  458.     Requires that a global by name of globalName
  459.     already be defined.
  460. */
  461.     XCmdPtr     paramPtr;
  462.     char        *container;
  463.     Handle        *hGlobalData;
  464. {
  465.     char        msg[kMaxLenLine],
  466.                 globalName[kMaxLenGlobal];
  467.     Str255        globalPname;
  468.     Handle        hTemp;
  469.     
  470.                                             /*    create global                    */
  471.     copyPstr(globalPname, kTmpGlobalPname);
  472.     copyPtoCstr(globalName, globalPname);
  473.     hTemp = putGlobal(paramPtr, globalPname, container);
  474.                                             /*    put container into global        */
  475.     strcpy(msg, "put ");
  476.     strcat(msg, container);
  477.     strcat(msg, " into ");
  478.     strcat(msg, globalName);
  479.     SendCstrHCMsg(paramPtr, msg);
  480.                                             /*    "SendHCMsg error in get: "        */
  481.     CHK_CALLBACK_ERR(msg);
  482.                                             /*    get data from global            */
  483.     *hGlobalData = GetGlobal(paramPtr, globalPname);
  484.                                             /*    "GetGlobal error (copy) in get:"*/
  485.     CHK_CALLBACK_ERR(globalName);
  486.     DisposHandle(hTemp);
  487.     
  488. }    /*    --------------------------------------------    getContainerData        */
  489.  
  490. int putContainerData(paramPtr, container, hData)
  491. /*
  492.     Put the hData into the container described in "container".
  493.     The HyperCard data is stored as a C string.
  494.     hData is checked for non-NIL before proceeding.
  495.     Returns TRUE if the put was done.
  496.     
  497.     Method:
  498.     
  499.         Create a HC global.
  500.         Copy the data to the HC global.
  501.         Send a message to HC to put the global into a container.
  502. */
  503.     XCmdPtr     paramPtr;
  504.     char        *container;
  505.     Handle        hData;
  506. {
  507.     char        msg[kMaxLenLine],
  508.                 globalName[kMaxLenGlobal];
  509.     Str255        globalPname;
  510.     Handle        hTemp;
  511.     
  512.                                 /*    make sure we have desc and handle            */
  513.     if(hData==NIL || strlen(container)<=0)
  514.         return FALSE;
  515.                                             /*    create global                    */
  516.     copyPstr(globalPname, kTmpGlobalPname);
  517.     copyPtoCstr(globalName, globalPname);
  518.     hTemp = putGlobal(paramPtr, globalPname, container);
  519.                                 /*    have container desc and handle                */
  520.                                 /*    copy handle data to temp HC global            */
  521.     SetGlobal(paramPtr, globalPname, hData);
  522.                                 /*    "SetGlobal error (copy) in put: "            */
  523.     CHK_CALLBACK_ERR(globalName);
  524.                                 /*    Have HC copy from global to container        */
  525.     strcpy(msg, "put ");
  526.     strcat(msg, globalName);
  527.     strcat(msg, " into ");
  528.     strcat(msg, container);
  529.     SendCstrHCMsg(paramPtr, msg);
  530.                                 /*    "SendHCMsg error in put: "                    */
  531.     CHK_CALLBACK_ERR(msg);
  532.     DisposHandle(hTemp);
  533.     return TRUE;    
  534. }    /*    --------------------------------------------    putContainerData        */
  535.  
  536. #define        CHK_CALLBACK_ERR(str)                        \
  537.             {                                            \
  538.                 short    result;                            \
  539.                 char    msg[128];                        \
  540.                 if((result=paramPtr->result)!=0)        \
  541.                 {                                        \
  542.                     strcpy(msg, "HC callback error: ");    \
  543.                     strcat(msg, str);                    \
  544.                     DebugStr(ToPstr(msg));                \
  545.                 }                                        \
  546.             }
  547.  
  548. typedef struct
  549. {
  550.     short    num_sessions;
  551.     short    reserved;
  552.     char    method_global_name[kMaxLenName];
  553.     Handle    hSession[kMaxSessions];
  554. } masBlk;
  555.  
  556. typedef struct
  557. {
  558.     char    session_global_name[kMaxLenName];
  559.     BYTE    conn_id;
  560.     BYTE    port_id;
  561.     BYTE    ps_id;
  562.     BYTE    flags;
  563.     char    status[kMaxLenStat];
  564.     Handle    hAPIvars;
  565.     Handle    hReq[kMaxReq];
  566.     Handle    hQueue[kMaxQ];
  567.     Handle    hTable[kMaxTab];
  568.     short    tableLen[kMaxTab];
  569.     Handle    hBuffer[kMaxBuf];
  570.     Handle    hRecord[kMaxRec];
  571. } sesBlk;
  572.  
  573.     "masHan",    {
  574.         "master handle",        "^masBlk",            1
  575.         },
  576.         
  577.     "masBlk",    {
  578.         "num_sessions",            "Word",                1,
  579.         "reserved",                "Word",                1,
  580.         "method name",            "Text",                32,
  581.         "hSession1",            "^^sesBlk",            1,
  582.         "hSession2",            "^^sesBlk",            1,
  583.         "hSession3",            "^^sesBlk",            1,
  584.         "hSession4",            "^^sesBlk",            1,
  585.         "hSession5",            "^^sesBlk",            1,
  586.         "hSession6",            "^^sesBlk",            1,
  587.         "hSession7",            "^^sesBlk",            1,
  588.         "hSession8",            "^^sesBlk",            1
  589.         },
  590.         
  591.     "sesBlk",    {
  592.         "global_name",            "Text",                32,
  593.         "conn_id",                "Byte",                1,
  594.         "port_id",                "Byte",                1,
  595.         "ps_id",                "Byte",                1,
  596.         "flags",                "Byte",                1,
  597.         "status",                "Text",                12,
  598.         "hAPIvars",                "Long",                1,
  599.         "hReq0-4",                "Long",                5,
  600.         "hReq5-9",                "Long",                5,
  601.         "hQueue0-3",            "Long",                4,
  602.         "hQueue4-7",            "Long",                4,
  603.         "hTables0-4",            "Long",                5,
  604.         "tableLen0-4",            "Word",                5,
  605.         "hBuffer",                "Long",                6,
  606.         "hRecord",                "Long",                4
  607.         },
  608.         
  609. /* -----------------------------------------------------------------
  610.     Program:        DebugStr XCMD
  611.     
  612.     Version:        v1.0a
  613.     
  614.     History:        05/01/89    v1.0a, original
  615.                     05/19/89    v1.1, use NewHandle rather than "char" for P-string
  616.                     05/25/89    v1.2, pass HC Handle directly rather than copy
  617.     
  618.     Author:            John R. Powers, III
  619.                     Easy Street Software
  620.                     16373 Alexander Avenue
  621.                     Monte Sereno, CA 95030
  622.                     (408) 395-1158
  623.                     (408) 395-3308 msg.
  624.  
  625.     Computer:        Mac II with System v6.0.2
  626.     
  627.     Compiler:        MPW-C v3.0    
  628.  
  629.     Usage:
  630.     
  631.         DebugStr(string-to-pass-to-MacsBug)
  632.         
  633.         Requires HyperCard version 1.2 or better.
  634.         Checks for DebugStr trap before attempting to call it.
  635.         If not present, doesn't make call.
  636.         
  637.     Files:
  638.     
  639.         DebugStr.c            This source file
  640.         TriData3270 Lab        HyperCard stack for testing
  641.         
  642.     Full Build:
  643.  
  644.         C -b  DebugStr.c -mbg off -sym off
  645.         Link -w ∂
  646.             -rt XCMD=16373 ∂
  647.             -m ENTRYPOINT ∂
  648.             -sg DebugStr ∂
  649.             DebugStr.c.o ∂
  650.             "{Libraries}"HyperXLib.o ∂
  651.             "{Libraries}"Interface.o ∂
  652.             "{CLibraries}"StdCLib.o ∂
  653.             "{CLibraries}"CRuntime.o ∂
  654.             -o "TriData3270 Lab"
  655.         save -a
  656.         
  657. ----------------------------------------------------------------- */
  658.  
  659. #include    <HyperXCmd.h>
  660. #include    <Memory.h>
  661. #include    <OSUtils.h>
  662. #include    <Types.h>
  663.  
  664. /*
  665.     some trap definitions in case we are not using MPW 3.0
  666. */
  667.  
  668. #ifndef        _DebugStr
  669. #define        _DebugStr        0xABFF
  670. #endif
  671.  
  672. #ifndef        _Unimplemented
  673. #define        _Unimplemented    0xA89F
  674. #endif
  675.  
  676. /*
  677.     other definitions
  678. */
  679.  
  680. #define        TRUE    1
  681. #define        FALSE    0
  682.  
  683. /*
  684.     prototypes
  685. */
  686.  
  687. Boolean trapAvailable(short tNumber, short tType);
  688. Boolean isImplemented(short trap);
  689. char *ToCstr(char * str);
  690. char *ToPstr(char * str);
  691.  
  692. /*
  693.         main program and entry point
  694. */
  695.  
  696. pascal void    EntryPoint(paramPtr)
  697.  
  698.     XCmdPtr     paramPtr;                        /*    the HyperCard connection    */
  699. {
  700.     Handle        hBugCstr;
  701.     
  702.     if(!isImplemented(_DebugStr))
  703.         return;
  704.     if(paramPtr->paramCount==1)
  705.     {
  706.         HLock(hBugCstr = paramPtr->params[0]);    /*    get first parameter            */
  707.         DebugStr((Str255) ToPstr(*hBugCstr));    /*    convert to P-string and pass*/
  708.         ToCstr(*hBugCstr);                        /*    restore to C-string            */
  709.         HUnlock(hBugCstr);
  710.     }
  711.     else                                        /*    no string to pass            */
  712.         Debugger();
  713.     
  714. }    /*    --------------------------------------------    EntryPoint            */
  715.  
  716.  
  717. Boolean trapAvailable(tNumber, tType)
  718. /*
  719.     Test to see if the trap is available.
  720.     Adapted from p.3-12 to 3-14 in Programmer's Guide to Multifinder.
  721.     APDA #KMB017
  722. */
  723.     short int        tNumber;
  724.     short int        tType;
  725. {
  726.     return(NGetTrapAddress(tNumber, tType) != GetTrapAddress(_Unimplemented));
  727.  
  728. }                                /*    end trapAvailable    -----------------------    */
  729.  
  730. Boolean isImplemented(trap)
  731. /*
  732.     Check to see if trap is implemented.
  733.     Adapted from p.3-12 to 3-14 in Programmer's Guide to Multifinder.
  734.     APDA #KMB017
  735. */
  736.     short int        trap;
  737. {
  738.     SysEnvRec    theWorld;
  739.     
  740.     SysEnvirons(1, &theWorld);    /*    does this machine support trap tables?        */
  741.     if(theWorld.machineType < 0)
  742.         return(FALSE);            /*    this ROM does not trap tables or trap        */
  743.     else
  744.         return(trapAvailable(trap, ToolTrap));    /* check for trap                */
  745.         
  746. }                                /*    end isImplemented        ------------------    */
  747.  
  748. /*
  749.     Converts a Pascal string to a C string.
  750.     The Pascal string is overwritten in the process.
  751. */
  752. char *ToCstr(str)
  753.     char            *str;
  754. {
  755.     unsigned char    length,
  756.                     i;
  757.     
  758.     length = str[0];
  759.     for (i = 0; i < length; ++i)            /* Shift string 1 byte to the left */
  760.         str[i] = str[i+1];
  761.     str[length] = 0;                        /* Put zero-terminator after string */
  762.     return(str);
  763. }
  764.  
  765.  
  766. /*
  767.     Convert a C string to a Pascal string.
  768.     The C string is overwritten in the process.
  769. */
  770. char *ToPstr(str)
  771.     char             *str;
  772. {
  773.     unsigned char    length,
  774.                     i;
  775.     
  776.     for (i = 0, length = 0; str[i] != 0; ++i)    /* Find end of string            */
  777.         ++length;
  778.     while (i--)                                    /* Shift string 1 byte to right    */
  779.         str[i+1] = str[i];
  780.     str[0] = length;                            /* Put string length in 1st byte*/
  781.     return(str);
  782. }
  783.  
  784. short fetchDebugFlag(paramPtr, globalPname)
  785. /*
  786.     Fetch the debugFlag stored in globalPname
  787.     
  788.     Returns the debugFlag, 0 if no global found.
  789. */
  790.     XCmdPtr     paramPtr;                        /*    HyperCard connection    */
  791.     Str255        globalPname;
  792. {
  793.     Handle        hGlobalString;                    /*    string stored in global    */
  794.     Str255        globalPstr;
  795.     long        longFlag;
  796.     
  797.     HLock(hGlobalString = GetGlobal(paramPtr, globalPname));
  798.     copyCtoPstr(globalPstr, *hGlobalString);
  799.     StringToNum(globalPstr, &longFlag);
  800.     HUnlock(hGlobalString);
  801.     return (longFlag & 0xFFFF);
  802. }    /*    --------------------------------------------    fetchDebugFlag        */
  803.  
  804.  
  805. #define        DEBUG_AFTER(flag)                            \
  806.             {                                            \
  807.                 if(flag==kDebugAfter||flag==kDebugBoth)    \
  808.                     DebugStr("\pAfter");                \
  809.             }
  810.             
  811. #define        DEBUG_BEFORE(flag)                            \
  812.             {                                            \
  813.                 if(flag==kDebugBefore||flag==kDebugBoth)\
  814.                     DebugStr("\pBefore");                \
  815.             }
  816.             
  817.